Instalación de Entorno de trabajo. Ubuntu WSL2

Ingeniería Biomédica

Tutorial

Instalación de Ubuntu en WSL

Antes de compilar Python, es necesario disponer de Ubuntu corriendo bajo WSL2 en Windows 11. Sigue estos pasos:

1. Verificar requisitos:

   • Windows 11 (build 22000 o superior).
   • Virtualización habilitada en BIOS/UEFI (Intel VT-x o AMD SVM).
   • Permisos de administrador en Windows.

2. Habilitar WSL y plataforma de máquina virtual:

   Abre PowerShell como administrador y ejecuta: powershell wsl --install

   • Esto activa las características “Virtual Machine Platform” y “Windows Subsystem for Linux”.
   • Descarga e instala Ubuntu por defecto (puedes ignorar o desinstalar luego).
   • Reinicia el equipo si se solicita.

3. Instalar Ubuntu:

   • Vía PowerShell:

     wsl --install -d Ubuntu

   • O desde Microsoft Store:

     1. Abre Microsoft Store.
     2. Busca “Ubuntu” y pulsa Instalar.

4. Primer arranque de Ubuntu:

   1. Abre Ubuntu desde el menú Inicio o Windows Terminal. powershell wsl -d Ubuntu
   2. Crea tu usuario y contraseña de Linux.

5. Actualizar paquetes del sistema:

   sudo apt update && sudo apt upgrade -y

Instalación de R y Python

1. Actualizar repositorios e instalar dependencias de compilación

Ejecuta los siguientes comandos para actualizar el sistema e instalar las bibliotecas necesarias para compilar Python desde el código fuente:

sudo apt update
sudo apt install -y \
  build-essential \
  checkinstall \
  libncurses-dev \
  libssl-dev \
  zlib1g \
  zlib1g-dev \
  libreadline-dev \
  libsqlite3-dev \
  libgdbm-dev libdb5.3-dev \
  libbz2-dev \
  libexpat1-dev \
  libc6-dev \
  libffi-dev \
  liblzma-dev \
  tk-dev \
  dirmngr \
  gnupg \
  apt-transport-https \
  ca-certificates \
  software-properties-common wget \
  libxml2-dev \
  libharfbuzz-dev \
  libfribidi-dev \
  libcurl4-openssl-dev \
  libmagick++-dev \
  libnsl-dev \
  cmake\
  wget\
  fonts-jetbrains-mono\
  fonts-firacode\
  fonts-cascadia-code\
  fonts-inter\
  fonts-ibm-plex\
  fonts-manrope\
  fonts-ebgaramond\
  fonts-lmodern\
  fonts-noto\
  fonts-noto-mono\
  fonts-noto-color-emoji

2. Obtener el kit de repositorio CUDA de NVIDIA:

cd ~
mkdir instaladores
cd instaladores
wget https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-wsl-ubuntu.pin
sudo mv cuda-wsl-ubuntu.pin /etc/apt/preferences.d/cuda-repository-pin-600
wget https://developer.download.nvidia.com/compute/cuda/12.9.1/local_installers/cuda-repo-wsl-ubuntu-12-9-local_12.9.1-1_amd64.deb
sudo dpkg -i cuda-repo-wsl-ubuntu-12-9-local_12.9.1-1_amd64.deb
sudo apt update
sudo apt -y install cuda-toolkit-12-9

3. Verificar la instalación:

# Verifica la versión de nvcc
nvcc --version
# Verifica que la GPU sea detectada
nvidia-smi

4. Instalación de la versión más reciente de R

Para instalar la versión más reciente de R en Ubuntu bajo WSL2, sigue estos pasos:

1. Agregar la clave y el repositorio oficial de CRAN:

wget -qO- https://cloud.r-project.org/bin/linux/ubuntu/marutter_pubkey.asc | sudo tee -a /etc/apt/trusted.gpg.d/cran_ubuntu_key.asc
sudo add-apt-repository "deb https://cloud.r-project.org/bin/linux/ubuntu $(lsb_release -cs)-cran40/"

2. Instalar R:

sudo apt update
sudo apt install -y r-base r-base-dev r-recommended

3. Verificar la instalación:

R --version    # Debe mostrar la versión de R recién instalada
sudo R
install.packages(c("DiagrammeR", "reticulate", "kableExtra", "tidyverse", "knitr", "cowplot", "ggfx", "rstatix", "languageserver", "bibliometrix"))

Introducción

En el desarrollo de IA confiable y el procesamiento de señales biomédicas, la reproducibilidad es un pilar fundamental. El uso de uv, desarrollado por Astral, proporciona una gestión de dependencias y entornos Python significativamente más rápida y robusta que las herramientas tradicionales (pip, venv, conda).

1. Instalación de uv

Para instalar uv de forma aislada en Ubuntu 24.04, se utiliza el script de instalación oficial. Este método evita conflictos con el gestor de paquetes del sistema (apt).

# Descarga e instalación del binario
curl -LsSf [https://astral.sh/uv/install.sh](https://astral.sh/uv/install.sh) | sh

# Actualización del entorno de shell (o reiniciar terminal)
source $HOME/.cargo/env

2. Gestión de Versiones de Python

Como investigador, es probable que requiera versiones específicas para garantizar la compatibilidad de librerías de procesamiento de imágenes. uv gestiona estas instalaciones de forma transparente.

# Instalación de una versión específica
uv python install 3.12

# Listado de versiones disponibles y detectadas
uv python list

3. Flujo de Trabajo en Proyectos de Biomecánica

Para asegurar la integridad de los experimentos, cada proyecto debe estar encapsulado.

Inicialización

El comando init genera un archivo pyproject.toml compatible con los estándares modernos de empaquetado (PEP 621).

uv init

Creación y Activación de Entornos

# Crear entorno virtual con versión específica
uv venv --python 3.12

# Activación en Linux
source .venv/bin/activate

4. Gestión de Dependencias y Reproducibilidad

El archivo uv.lock garantiza que todos los colaboradores (o procesos de CI/CD) utilicen las mismas versiones de las librerías, minimizando la incertidumbre en los resultados de IA Causal.

Comando	Función
uv add <paquete>	Añade una dependencia al proyecto y actualiza el lockfile.
uv remove <paquete>	Elimina una dependencia.
uv sync	Sincroniza el entorno local con el archivo de bloqueo.

Ejemplo práctico para procesamiento de señales:

uv add numpy scipy pandas matplotlib

5. Integración con Quarto e IA

Para la generación de diapositivas o reportes técnicos, Quarto debe apuntar al intérprete del entorno virtual creado.

# Ejemplo de renderización usando el entorno del proyecto
uv run quarto render documento.qmd

Nota Académica: La adopción de uv no solo optimiza el tiempo de cómputo en la resolución de dependencias, sino que mitiga riesgos asociados a la mutabilidad de los entornos de desarrollo, un paso necesario hacia una IA más confiable y reproducible.

---

# Verificación de entorno dentro de un bloque de código Quarto
import sys
import os

print(f"Intérprete en uso: {sys.executable}")
print(f"Versión de Python: {sys.version}")

6. Descargar y extraer Python 3.12

1. Descarga el código fuente de Python 3.12 y descomprímelo en /usr/src:

cd /usr/src
sudo wget https://www.python.org/ftp/python/3.12.11/Python-3.12.11.tgz
sudo tar -xzf Python-3.12.11.tgz
cd Python-3.12.11

2. Configura la compilación con optimizaciones y el instalador de pip integrado:

```bash
sudo ./configure --enable-optimizations --with-ensurepip=install --enable-shared
```

3. Compila utilizando todos los núcleos disponibles:

```bash
sudo make -j $(nproc)
```

4. Instala Python 3.12 sin sobrescribir la versión del sistema por defecto:

```bash
sudo make altinstall
```

Los ejecutables quedarán en /usr/local/bin/python3.12 y /usr/local/bin/pip3.12.

5. Verificación de la instalación

Comprueba las versiones instaladas:

/usr/local/bin/python3.12 --version   # Debe mostrar Python 3.12.0
/usr/local/bin/pip3.12 --version      # Debe mostrar la versión de pip correspondiente
echo 'export PATH="$PATH:/home/sylph/.local/bin"' >> ~/.bashrc
source

6. Crear y activar un entorno virtual

1. Crea un directorio de trabajo

```bash
mkdir -p ~/proyectos
cd ~/proyectos
```

2. Crea un entorno virtual (mienv) con Python 3.12:

```bash
/usr/local/bin/python3.12 -m venv mienv
```

3. Activa el entorno:

```bash
source mienv/bin/activate
```

4. Verifica que python y pip apunten a la versión 3.12:

```bash
python --version   # Python 3.12.X
pip --version      # pip x.y.z
```

5. Instala las bibliotecas necesarias:

```bash
python -m pip cache purge
python -m pip install -U --upgrade-strategy eager pip setuptools wheel packaging build
python -m pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu129
python -m pip install pandas matplotlib scikit-learn opencv-contrib-python opencv-python pywavelets statsmodels scipy seaborn plotly scikit-image scikit-image[data] scikit-image[optional] jupyter scikit-image
```

5. desactivar el entorno, ejecuta:

deactivate

Instalación de Miniconda3 en Ubuntu (WSL)

A continuación se detallan los pasos estrictamente por terminal para instalar Miniconda3 en tu entorno Ubuntu bajo WSL.

1. Actualizar índices de paquetes

sudo apt update

2. Descargar el instalador oficial

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda.sh

3. Verificar la integridad (opcional)

Compara el hash SHA‑256 generado con el publicado en el sitio oficial:

sha256sum ~/miniconda.sh
# Comprueba que el resultado coincida con el valor en https://repo.anaconda.com/miniconda/

4. Ejecutar el instalador en modo silencioso

Esto instalará Miniconda en ~/miniconda sin interacción:

bash ~/miniconda.sh -b -p $HOME/miniconda

5. Inicializar Conda en tu shell

Para que conda esté disponible cada vez que abras la terminal:

eval "$(~/miniconda/bin/conda shell.bash hook)"
conda init

6. Recargar la configuración de shell

source ~/.bashrc

7. Actualizar Conda a la última versión

conda tos interactive
conda update -n base -c defaults conda -y

8. Verificar la instalación

conda --version
# Deberías ver algo como: conda 23.x.x

9. Crear un entorno virtual

conda create -n ai-env python=3.12

Instalación de Texlive (LATEX)

sudo apt update
sudo apt install texlive-full

Instalación de Quarto

Se requiere revisarr la versión de Quarto disponible en la página de descargas de Quarto https://quarto.org/docs/get-started/.

sudo apt update
wget https://github.com/quarto-dev/quarto-cli/releases/download/v1.7.32/quarto-1.7.32-linux-amd64.deb
sudo dpkg -i quarto-1.7.32-linux-amd64.deb
sudo apt-get install -f

---